//import java.util.*;
//
//class Variable {
//    String type;
//    Object value; // Integer for int, Double for float, null if unassigned
//
//    Variable(String type, Object value) {
//        this.type = type;
//        this.value = value;
//    }
//
//    @Override
//    public String toString() {
//        return type + " " + (value != null ? value : "unassigned");
//    }
//}
//
//class Number {
//    double value;
//    boolean isInteger;
//
//    Number(double value, boolean isInteger) {
//        this.value = value;
//        this.isInteger = isInteger;
//    }
//}
//
//public class Main {
//    private static Map<String, Variable> variables = new HashMap<>();
//    private static String expression = null;
//
//    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
//
//        while (scanner.hasNextLine()) {
//            String line = scanner.nextLine().trim();
//            if (line.isEmpty()) continue;
//
//            // 检查是否是表达式行（以=?结尾）
//            if (line.endsWith("=?")) {
//                expression = line.substring(0, line.length() - 2).trim();
//                break; // 遇到表达式行后停止读取
//            }
//
//            // 处理分号和等号，把它们当作分隔符
//            line = line.replace("=", " ").replace(";", " ").trim();
//            String[] parts = line.split("\\s+");
//
//            try {
//                if (parts.length == 2) {
//                    // 可能是变量声明（int x）或赋值（x 3）
//                    if (parts[0].equals("int") || parts[0].equals("float")) {
//                        // 变量声明（int x）
//                        parseVariableDeclaration(parts[0], parts[1], null);
//                    } else {
//                        // 赋值（x 3）
//                        parseAssignment(parts[0], parts[1]);
//                    }
//                } else if (parts.length == 3) {
//                    // 带初始化的变量声明（int x 3）
//                    parseVariableDeclaration(parts[0], parts[1], parts[2]);
//                } else {
//                    throw new RuntimeException("Invalid line format: " + line);
//                }
//            } catch (RuntimeException e) {
//                System.out.println(e.getMessage());
//                return;
//            }
//        }
//        scanner.close();
//
////        // 打印所有变量（调试用）
////        System.out.println("Variables:");
////        for (Map.Entry<String, Variable> entry : variables.entrySet()) {
////            System.out.println(entry.getKey() + ": " + entry.getValue());
////        }
//
//        // 检查表达式
//        if (expression != null) {
//            try {
//                checkExpression(expression);
//                // 替换变量为数值
//                String replacedExpr = replaceVariables(expression);
//                //System.out.println("Replaced expression: " + replacedExpr);
//
//                // 使用自定义表达式求值方法
//                Number result = evaluateExpression(replacedExpr);
//                if (result.isInteger) {
//                    System.out.println((int)result.value);
//                } else {
//                    System.out.printf("%.2f\n", result.value);
//                }
//
//            } catch (RuntimeException e) {
//                System.out.println(e.getMessage());
//                return;
//            }
//        }
//    }
//
//    private static void parseVariableDeclaration(String type, String varName, String valueStr) {
//        if (!type.equals("int") && !type.equals("float")) {
//            throw new RuntimeException("Invalid type: " + type);
//        }
//
//        if (variables.containsKey(varName)) {
//            throw new RuntimeException("Duplicate variable: " + varName);
//        }
//
//        Object value = null;
//        if (valueStr != null) {
//            try {
//                if (type.equals("int")) {
//                    value = Integer.parseInt(valueStr);
//                } else {
//                    value = Double.parseDouble(valueStr);
//                }
//            } catch (NumberFormatException e) {
//                throw new RuntimeException("Invalid value for " + type + ": " + valueStr);
//            }
//        }
//
//        variables.put(varName, new Variable(type, value));
//    }
//
//    private static void parseAssignment(String varName, String valueStr) {
//        Variable var = variables.get(varName);
//        if (var == null) {
//            throw new RuntimeException("wrong - variable undefined");
//        }
//
//        try {
//            if (var.type.equals("int")) {
//                var.value = Integer.parseInt(valueStr);
//            } else {
//                var.value = Double.parseDouble(valueStr);
//            }
//        } catch (NumberFormatException e) {
//            throw new RuntimeException("Invalid value for " + var.type + ": " + valueStr);
//        }
//    }
//
//    private static void checkExpression(String expr) {
//        // 检查括号匹配
//        if (!checkParentheses(expr)) {
//            throw new RuntimeException("wrong - error expression");
//        }
//
//        // 提取所有变量名并检查
//        Set<String> varsInExpr = extractVariables(expr);
//        for (String varName : varsInExpr) {
//            Variable var = variables.get(varName);
//            if (var == null) {
//                throw new RuntimeException("wrong - variable undefined");
//            }
//            if (var.value == null) {
//                throw new RuntimeException("wrong - variable unassigned");
//            }
//        }
//    }
//
//    private static boolean checkParentheses(String expr) {
//        Deque<Character> stack = new ArrayDeque<>();
//        for (char c : expr.toCharArray()) {
//            if (c == '(') {
//                stack.push(c);
//            } else if (c == ')') {
//                if (stack.isEmpty() || stack.pop() != '(') {
//                    return false;
//                }
//            }
//        }
//        return stack.isEmpty();
//    }
//
//    private static Set<String> extractVariables(String expr) {
//        Set<String> variables = new HashSet<>();
//        StringBuilder currentVar = new StringBuilder();
//        boolean inVar = false;
//
//        for (char c : expr.toCharArray()) {
//            if (Character.isLetter(c) || c == '_') {
//                currentVar.append(c);
//                inVar = true;
//            } else {
//                if (inVar) {
//                    variables.add(currentVar.toString());
//                    currentVar.setLength(0);
//                    inVar = false;
//                }
//            }
//        }
//        // 添加最后一个变量（如果有）
//        if (inVar) {
//            variables.add(currentVar.toString());
//        }
//
//        return variables;
//    }
//
//    private static String replaceVariables(String expr) {
//        StringBuilder result = new StringBuilder();
//        StringBuilder currentVar = new StringBuilder();
//        boolean inVar = false;
//
//        for (char c : expr.toCharArray()) {
//            if (Character.isLetter(c) || c == '_') {
//                currentVar.append(c);
//                inVar = true;
//            } else {
//                if (inVar) {
//                    // 替换变量为数值
//                    String varName = currentVar.toString();
//                    Variable var = variables.get(varName);
//                    if (var.type.equals("int")) {
//                        result.append(((Integer)var.value).toString());
//                    } else {
//                        result.append(((Double)var.value).toString());
//                    }
//                    currentVar.setLength(0);
//                    inVar = false;
//                }
//                result.append(c);
//            }
//        }
//        // 处理最后一个变量（如果有）
//        if (inVar) {
//            String varName = currentVar.toString();
//            Variable var = variables.get(varName);
//            if (var.type.equals("int")) {
//                result.append(((Integer)var.value).toString());
//            } else {
//                result.append(((Double)var.value).toString());
//            }
//        }
//
//        return result.toString();
//    }
//
//    private static Number evaluateExpression(String expr) {
//        expr = expr.replaceAll("\\s+", "");
//        Stack<Number> nums = new Stack<>();
//        Stack<Character> ops = new Stack<>();
//
//        for (int i = 0; i < expr.length(); i++) {
//            char c = expr.charAt(i);
//
//            if (Character.isDigit(c) || c == '.') {
//                // 处理数字
//                StringBuilder sb = new StringBuilder();
//                boolean isInteger = true;
//                while (i < expr.length() && (Character.isDigit(expr.charAt(i)) || expr.charAt(i) == '.')) {
//                    if (expr.charAt(i) == '.') {
//                        isInteger = false;
//                    }
//                    sb.append(expr.charAt(i));
//                    i++;
//                }
//                i--;
//                nums.push(new Number(Double.parseDouble(sb.toString()), isInteger));
//            } else if (c == '-' && (i == 0 || expr.charAt(i-1) == '(' ||
//                    isOperator(expr.charAt(i-1)))) {
//                // 处理负数
//                i++;
//                StringBuilder sb = new StringBuilder("-");
//                boolean isInteger = true;
//                while (i < expr.length() && (Character.isDigit(expr.charAt(i)) || expr.charAt(i) == '.')) {
//                    if (expr.charAt(i) == '.') {
//                        isInteger = false;
//                    }
//                    sb.append(expr.charAt(i));
//                    i++;
//                }
//                i--;
//                nums.push(new Number(Double.parseDouble(sb.toString()), isInteger));
//            } else if (c == '(') {
//                ops.push(c);
//            } else if (c == ')') {
//                while (ops.peek() != '(') {
//                    nums.push(applyOp(ops.pop(), nums.pop(), nums.pop()));
//                }
//                ops.pop();
//            } else if (isOperator(c)) {
//                while (!ops.isEmpty() && precedence(ops.peek()) >= precedence(c)) {
//                    nums.push(applyOp(ops.pop(), nums.pop(), nums.pop()));
//                }
//                ops.push(c);
//            } else {
//                throw new RuntimeException("Invalid character");
//            }
//        }
//
//        while (!ops.isEmpty()) {
//            nums.push(applyOp(ops.pop(), nums.pop(), nums.pop()));
//        }
//
//        if (nums.size() != 1) {
//            throw new RuntimeException("Invalid expression");
//        }
//
//        return nums.pop();
//    }
//
//    private static Number applyOp(char op, Number b, Number a) {
//        switch (op) {
//            case '+':
//                return new Number(a.value + b.value, a.isInteger && b.isInteger);
//            case '-':
//                return new Number(a.value - b.value, a.isInteger && b.isInteger);
//            case '*':
//                return new Number(a.value * b.value, a.isInteger && b.isInteger);
//            case '/':
//                if (b.value == 0) throw new RuntimeException("Division by zero");
//                if (a.isInteger && b.isInteger) {
//                    return new Number((int)(a.value / b.value), true);
//                }
//                return new Number(a.value / b.value, false);
//            case '%':
//                if (!a.isInteger || !b.isInteger) {
//                    throw new RuntimeException("Modulo requires integers");
//                }
//                return new Number((int)a.value % (int)b.value, true);
//            default:
//                throw new RuntimeException("Unknown operator");
//        }
//    }
//
//    private static boolean isOperator(char c) {
//        return c == '+' || c == '-' || c == '*' || c == '/' || c == '%';
//    }
//
//    private static int precedence(char op) {
//        switch (op) {
//            case '+':
//            case '-':
//                return 1;
//            case '*':
//            case '/':
//            case '%':
//                return 2;
//            default:
//                return 0;
//        }
//    }
//}

import java.util.*;
import java.util.logging.*;

class Variable {
    String type;
    Object value;

    Variable(String type, Object value) {
        this.type = type;
        this.value = value;
    }

    @Override
    public String toString() {
        return type + " " + (value != null ? value : "unassigned");
    }
}

class Number {
    double value;
    boolean isInteger;

    Number(double value, boolean isInteger) {
        this.value = value;
        this.isInteger = isInteger;
    }
}

public class Main {
    private static final Logger logger = Logger.getLogger(Main.class.getName());
    private static Map<String, Variable> variables = new HashMap<>();
    private static String expression = null;

    public static void main(String[] args) {
        // 配置日志
        setupLogger();

        logger.info("程序启动");

        Scanner scanner = new Scanner(System.in);
        logger.info("等待用户输入...");

        while (scanner.hasNextLine()) {
            String line = scanner.nextLine().trim();
            if (line.isEmpty()) {
                logger.fine("跳过空行");
                continue;
            }

            logger.log(Level.FINE, "处理输入行: {0}", line);

            if (line.endsWith("=?")) {
                expression = line.substring(0, line.length() - 2).trim();
                logger.log(Level.INFO, "找到表达式: {0}", expression);
                break;
            }

            line = line.replace("=", " ").replace(";", " ").trim();
            String[] parts = line.split("\\s+");
            logger.log(Level.FINER, "分割后的部分: {0}", Arrays.toString(parts));

            try {
                if (parts.length == 2) {
                    if (parts[0].equals("int") || parts[0].equals("float")) {
                        logger.log(Level.FINE, "解析变量声明: {0} {1}", new Object[]{parts[0], parts[1]});
                        parseVariableDeclaration(parts[0], parts[1], null);
                    } else {
                        logger.log(Level.FINE, "解析变量赋值: {0} = {1}", new Object[]{parts[0], parts[1]});
                        parseAssignment(parts[0], parts[1]);
                    }
                } else if (parts.length == 3) {
                    logger.log(Level.FINE, "解析带初始化的变量声明: {0} {1} = {2}",
                            new Object[]{parts[0], parts[1], parts[2]});
                    parseVariableDeclaration(parts[0], parts[1], parts[2]);
                } else {
                    throw new RuntimeException("Invalid line format: " + line);
                }
            } catch (RuntimeException e) {
                logger.log(Level.SEVERE, "处理输入行时出错", e);
                System.out.println(e.getMessage());
                return;
            }
        }
        scanner.close();

        logger.info("变量列表:");
        for (Map.Entry<String, Variable> entry : variables.entrySet()) {
            logger.log(Level.INFO, "{0}: {1}",
                    new Object[]{entry.getKey(), entry.getValue()});
        }

        if (expression != null) {
            try {
                logger.log(Level.INFO, "开始检查表达式: {0}", expression);
                checkExpression(expression);

                String replacedExpr = replaceVariables(expression);
                logger.log(Level.INFO, "替换变量后的表达式: {0}", replacedExpr);

                Number result = evaluateExpression(replacedExpr);
                logger.log(Level.INFO, "计算结果: {0}", result.value);

                if (result.isInteger) {
                    System.out.println((int)result.value);
                } else {
                    System.out.printf("%.2f\n", result.value);
                }

            } catch (RuntimeException e) {
                logger.log(Level.SEVERE, "处理表达式时出错", e);
                System.out.println(e.getMessage());
                return;
            }
        }

        logger.info("程序结束");
    }

    private static void setupLogger() {
        try {
            // 创建文件处理器，日志输出到文件
            FileHandler fileHandler = new FileHandler("calculator.log");
            fileHandler.setFormatter(new SimpleFormatter());

            // 创建控制台处理器
            ConsoleHandler consoleHandler = new ConsoleHandler();
            consoleHandler.setFormatter(new SimpleFormatter());

            // 配置根logger
            Logger rootLogger = Logger.getLogger("");
            for (Handler handler : rootLogger.getHandlers()) {
                rootLogger.removeHandler(handler);
            }

            // 添加自定义处理器
            logger.addHandler(fileHandler);
            logger.addHandler(consoleHandler);

            // 设置日志级别
            logger.setLevel(Level.ALL);
            fileHandler.setLevel(Level.ALL);
            consoleHandler.setLevel(Level.INFO); // 控制台只输出INFO及以上级别

        } catch (Exception e) {
            System.err.println("无法配置日志: " + e.getMessage());
        }
    }

    private static void parseVariableDeclaration(String type, String varName, String valueStr) {
        logger.log(Level.FINER, "开始解析变量声明: type={0}, name={1}, value={2}",
                new Object[]{type, varName, valueStr});

        if (!type.equals("int") && !type.equals("float")) {
            throw new RuntimeException("Invalid type: " + type);
        }

        if (variables.containsKey(varName)) {
            throw new RuntimeException("Duplicate variable: " + varName);
        }

        Object value = null;
        if (valueStr != null) {
            try {
                if (type.equals("int")) {
                    value = Integer.parseInt(valueStr);
                } else {
                    value = Double.parseDouble(valueStr);
                }
            } catch (NumberFormatException e) {
                throw new RuntimeException("Invalid value for " + type + ": " + valueStr);
            }
        }

        variables.put(varName, new Variable(type, value));
        logger.log(Level.FINE, "成功添加变量: {0}", varName);
    }

    private static void parseAssignment(String varName, String valueStr) {
        logger.log(Level.FINER, "开始解析变量赋值: name={0}, value={1}",
                new Object[]{varName, valueStr});

        Variable var = variables.get(varName);
        if (var == null) {
            throw new RuntimeException("wrong - variable undefined");
        }

        try {
            if (var.type.equals("int")) {
                var.value = Integer.parseInt(valueStr);
            } else {
                var.value = Double.parseDouble(valueStr);
            }
            logger.log(Level.FINE, "成功赋值: {0} = {1}", new Object[]{varName, var.value});
        } catch (NumberFormatException e) {
            throw new RuntimeException("Invalid value for " + var.type + ": " + valueStr);
        }
    }

    private static void checkExpression(String expr) {
        logger.log(Level.FINER, "开始检查表达式: {0}", expr);

        if (!checkParentheses(expr)) {
            throw new RuntimeException("wrong - error expression");
        }

        Set<String> varsInExpr = extractVariables(expr);
        logger.log(Level.FINE, "表达式中使用的变量: {0}", varsInExpr);

        for (String varName : varsInExpr) {
            Variable var = variables.get(varName);
            if (var == null) {
                throw new RuntimeException("wrong - variable undefined");
            }
            if (var.value == null) {
                throw new RuntimeException("wrong - variable unassigned");
            }
        }
    }

    private static boolean checkParentheses(String expr) {
        logger.log(Level.FINEST, "检查括号匹配: {0}", expr);

        Deque<Character> stack = new ArrayDeque<>();
        for (char c : expr.toCharArray()) {
            if (c == '(') {
                stack.push(c);
            } else if (c == ')') {
                if (stack.isEmpty() || stack.pop() != '(') {
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }

    private static Set<String> extractVariables(String expr) {
        logger.log(Level.FINEST, "提取变量名: {0}", expr);

        Set<String> variables = new HashSet<>();
        StringBuilder currentVar = new StringBuilder();
        boolean inVar = false;

        for (char c : expr.toCharArray()) {
            if (Character.isLetter(c) || c == '_') {
                currentVar.append(c);
                inVar = true;
            } else {
                if (inVar) {
                    variables.add(currentVar.toString());
                    currentVar.setLength(0);
                    inVar = false;
                }
            }
        }
        if (inVar) {
            variables.add(currentVar.toString());
        }

        return variables;
    }

    private static String replaceVariables(String expr) {
        logger.log(Level.FINER, "开始替换变量: {0}", expr);

        StringBuilder result = new StringBuilder();
        StringBuilder currentVar = new StringBuilder();
        boolean inVar = false;

        for (char c : expr.toCharArray()) {
            if (Character.isLetter(c) || c == '_') {
                currentVar.append(c);
                inVar = true;
            } else {
                if (inVar) {
                    String varName = currentVar.toString();
                    Variable var = variables.get(varName);
                    if (var.type.equals("int")) {
                        result.append(((Integer)var.value).toString());
                    } else {
                        result.append(((Double)var.value).toString());
                    }
                    currentVar.setLength(0);
                    inVar = false;
                }
                result.append(c);
            }
        }
        if (inVar) {
            String varName = currentVar.toString();
            Variable var = variables.get(varName);
            if (var.type.equals("int")) {
                result.append(((Integer)var.value).toString());
            } else {
                result.append(((Double)var.value).toString());
            }
        }

        return result.toString();
    }

    private static Number evaluateExpression(String expr) {
        logger.log(Level.FINER, "开始计算表达式: {0}", expr);

        expr = expr.replaceAll("\\s+", "");
        Stack<Number> nums = new Stack<>();
        Stack<Character> ops = new Stack<>();

        for (int i = 0; i < expr.length(); i++) {
            char c = expr.charAt(i);

            if (Character.isDigit(c) || c == '.') {
                StringBuilder sb = new StringBuilder();
                boolean isInteger = true;
                while (i < expr.length() && (Character.isDigit(expr.charAt(i)) || expr.charAt(i) == '.')) {
                    if (expr.charAt(i) == '.') {
                        isInteger = false;
                    }
                    sb.append(expr.charAt(i));
                    i++;
                }
                i--;
                Number num = new Number(Double.parseDouble(sb.toString()), isInteger);
                nums.push(num);
                logger.log(Level.FINEST, "解析数字: {0} (整数: {1})",
                        new Object[]{num.value, num.isInteger});
            } else if (c == '-' && (i == 0 || expr.charAt(i-1) == '(' ||
                    isOperator(expr.charAt(i-1)))) {
                i++;
                StringBuilder sb = new StringBuilder("-");
                boolean isInteger = true;
                while (i < expr.length() && (Character.isDigit(expr.charAt(i)) || expr.charAt(i) == '.')) {
                    if (expr.charAt(i) == '.') {
                        isInteger = false;
                    }
                    sb.append(expr.charAt(i));
                    i++;
                }
                i--;
                Number num = new Number(Double.parseDouble(sb.toString()), isInteger);
                nums.push(num);
                logger.log(Level.FINEST, "解析负数: {0} (整数: {1})",
                        new Object[]{num.value, num.isInteger});
            } else if (c == '(') {
                ops.push(c);
                logger.log(Level.FINEST, "遇到左括号");
            } else if (c == ')') {
                logger.log(Level.FINEST, "遇到右括号，开始计算括号内表达式");
                while (ops.peek() != '(') {
                    nums.push(applyOp(ops.pop(), nums.pop(), nums.pop()));
                }
                ops.pop();
            } else if (isOperator(c)) {
                logger.log(Level.FINEST, "处理运算符: {0}", c);
                while (!ops.isEmpty() && precedence(ops.peek()) >= precedence(c)) {
                    nums.push(applyOp(ops.pop(), nums.pop(), nums.pop()));
                }
                ops.push(c);
            } else {
                throw new RuntimeException("Invalid character");
            }
        }

        logger.log(Level.FINER, "处理剩余运算符");
        while (!ops.isEmpty()) {
            nums.push(applyOp(ops.pop(), nums.pop(), nums.pop()));
        }

        if (nums.size() != 1) {
            throw new RuntimeException("Invalid expression");
        }

        return nums.pop();
    }

    private static Number applyOp(char op, Number b, Number a) {
        logger.log(Level.FINEST, "执行运算: {0} {1} {2}",
                new Object[]{a.value, op, b.value});

        switch (op) {
            case '+':
                return new Number(a.value + b.value, a.isInteger && b.isInteger);
            case '-':
                return new Number(a.value - b.value, a.isInteger && b.isInteger);
            case '*':
                return new Number(a.value * b.value, a.isInteger && b.isInteger);
            case '/':
                if (b.value == 0) throw new RuntimeException("Division by zero");
                if (a.isInteger && b.isInteger) {
                    return new Number((int)(a.value / b.value), true);
                }
                return new Number(a.value / b.value, false);
            case '%':
                if (!a.isInteger || !b.isInteger) {
                    throw new RuntimeException("Modulo requires integers");
                }
                return new Number((int)a.value % (int)b.value, true);
            default:
                throw new RuntimeException("Unknown operator");
        }
    }

    private static boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/' || c == '%';
    }

    private static int precedence(char op) {
        switch (op) {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
            case '%':
                return 2;
            default:
                return 0;
        }
    }
}